Image processing: Exploring geometric, logical and morphological operations in images + Color spaces (Part I)
This lab is composed of two parts.
You must submit a single lab report covering both Part I and Part II.
Part II will be sent before the start of next week's session.
The lab report is due by the end of the second lab session.
In this lab, you will explore essential image processing techniques that transform and enhance images, allowing you to extract meaningful insights. These foundational operations serve as building blocks for more advanced computer vision applications.
What you will learn in this Lab:
- You will understand the principles behind geometric transformations and logical operations in image processing.
- You will apply geometric transformations such as resizing, rotation, translation, and perspective modification to adjust image properties.
- You will perform bitwise logical operations to manipulate and combine images.
- Learn about morphological operations to enhance and extract structural information from images.
- Explore color spaces and how to convert between different color models for advanced image processing.
---
-----
Understanding the libraries used
Before starting the lab, provide a brief definition of the following libraries and their role in image processing:
- OpenCV: Open Source Computer Vision Library, primarily used for image and video processing tasks such as geometric transformations, filtering, and morphological operations.
- NumPy: A fundamental package for numerical computing in Python, providing support for arrays, matrices, and mathematical functions used in image processing.
- Matplotlib: A plotting library for Python that enables visualization of images, histograms, and transformations applied to images.
If not installed, you can install them using:
pip install opencv-python numpy matplotlibIn [2]:
import matplotlib.pyplot as plt import cv2 as cv import numpy as np
Manipulation 1: Geometric Transformations
You will explore geometric transformations and their role in image processing, including:
- Resizing (Scaling) – Adjusting the image dimensions while preserving or modifying aspect ratios.
- Translation – Moving an image to a different position without altering its content.
- Rotation – Changing the orientation of an image around a fixed point.
- Shearing – Slanting the image along an axis, distorting its shape.
- Perspective Transformation – Adjusting the image’s perspective to simulate different viewpoints.
Why are these transformations important?
They are widely used in various computer vision tasks, such as:
- Image alignment – Aligning images for analysis and comparison.
- Data augmentation – Creating variations of images for training machine learning models.
- Perspective correction – Fixing distortions in images for better representation and analysis.
Theoretical research: Provide bellow a description of the following key concepts (using your own words):
* Geometrical transformations : ...
* Logical operations : ...
* Morphological operations : ...
Task 1: Image scaling
#### T 1.1: Resizing algorithms
Explore and compare different image resizing methods. For each method, provide a description of how it works:
- Nearest neighbor (Simplest method, but may cause pixelation) : ...
- Bilinear interpolation (Better quality, considers neighboring pixels) : ...
- Bicubic interpolation (Higher quality, but more computationally expensive) : ...
---
Manual implementation of a resizing algorithm: Write a function that implements the nearest neighbor resizing algorithm manually, without using any built-in functions for resizing. The new size can be provided as absolute values and also as positive/negative ratios.
- Load the
cameraman.png image. - Resize the
cameraman.png image both up and down using the nearest neighbor method you have implemented. Perform at leat 6 differents resizings.- Display the original image along with its size.
- Display the resized images with their new sizes.
Hint: You can achieve this by iterating over the pixel values and mapping them to a new zero matrix (black image) with the desired size based on the chosen interpolation method. It is important to warn the user if the new size of the image does not preserve the aspect ratio (but the resize has to be performed anyway).
Perform the same work for another resizing method: Bilinear interpolation or Bicubic interpolation.
Analyse the obtained images.
In [4]:
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load the image
img = cv2.imread('Images\cameraman.png', cv2.IMREAD_GRAYSCALE) # grayscale
original_h, original_w = img.shape
print(f"Original size: {original_w}x{original_h}")
plt.imshow(img, cmap='gray')
plt.title(f'Original Image ({original_w}x{original_h})')
plt.show()
<>:6: SyntaxWarning: invalid escape sequence '\c'
<>:6: SyntaxWarning: invalid escape sequence '\c'
C:\Users\nesri\AppData\Local\Temp\ipykernel_13820\546096502.py:6: SyntaxWarning: invalid escape sequence '\c'
img = cv2.imread('Images\cameraman.png', cv2.IMREAD_GRAYSCALE) # grayscale
Original size: 256x256
In [5]:
def nearest_neighbor_resize(image, new_size):
"""
Resize the image using nearest neighbor interpolation.
new_size: tuple (new_width, new_height)
"""
old_h, old_w = image.shape
new_w, new_h = new_size
if new_w/old_w != new_h/old_h:
print("⚠️ Warning: Aspect ratio not preserved!")
resized = np.zeros((new_h, new_w), dtype=image.dtype)
for i in range(new_h):
for j in range(new_w):
# Mapping coordinates from new image to old image
x = int(j * old_w / new_w)
y = int(i * old_h / new_h)
resized[i, j] = image[y, x]
return resizedIn [6]:
# Define new sizes (both upscaling and downscaling)
sizes = [
(int(original_w*0.5), int(original_h*0.5)), # down 50%
(int(original_w*0.8), int(original_h*0.8)), # down 20%
(int(original_w*1.2), int(original_h*1.2)), # up 20%
(int(original_w*1.5), int(original_h*1.5)), # up 50%
(int(original_w*2), int(original_h*2)), # up 100%
(int(original_w*0.3), int(original_h*0.3)), # down 70%
]
# Resize and store images
nn_images = [nearest_neighbor_resize(img, sz) for sz in sizes]
# Display
plt.figure(figsize=(15,5))
plt.subplot(2, 4, 1)
plt.imshow(img, cmap='gray')
plt.title(f'Original ({original_w}x{original_h})')
plt.axis('off')
for i, resized in enumerate(nn_images):
plt.subplot(2, 4, i+2)
h, w = resized.shape
plt.imshow(resized, cmap='gray')
plt.title(f'{w}x{h}')
plt.axis('off')
plt.tight_layout()
plt.show()
In [8]:
def bilinear_resize(image, new_size):
old_h, old_w = image.shape
new_w, new_h = new_size
if new_w/old_w != new_h/old_h:
print("⚠️ Warning: Aspect ratio not preserved!")
resized = np.zeros((new_h, new_w), dtype=image.dtype)
for i in range(new_h):
for j in range(new_w):
x = j * (old_w - 1) / (new_w - 1)
y = i * (old_h - 1) / (new_h - 1)
x0 = int(np.floor(x))
x1 = min(x0 + 1, old_w - 1)
y0 = int(np.floor(y))
y1 = min(y0 + 1, old_h - 1)
a = x - x0
b = y - y0
# Bilinear interpolation formula
resized[i,j] = (1-a)*(1-b)*image[y0,x0] + a*(1-b)*image[y0,x1] + (1-a)*b*image[y1,x0] + a*b*image[y1,x1]
return resized.astype(np.uint8)In [9]:
# Resize and store images
bilinear_images = [bilinear_resize(img, sz) for sz in sizes]
# Display
plt.figure(figsize=(15,5))
plt.subplot(2, 4, 1)
plt.imshow(img, cmap='gray')
plt.title(f'Original ({original_w}x{original_h})')
plt.axis('off')
for i, resized in enumerate(bilinear_images):
plt.subplot(2, 4, i+2)
h, w = resized.shape
plt.imshow(resized, cmap='gray')
plt.title(f'{w}x{h}')
plt.axis('off')
plt.tight_layout()
plt.show()
| Resizing Method | Pros | Cons |
|---------------------|-------------------------------------------|-------------------------------------------|
| Nearest Neighbor | Very fast and simple
Preserves hard edges | Pixelation when upscaling
Jagged edges |
| Bilinear | Smooth result
Better quality than NN | Slight blur on sharp edges
Slower than NN |
| Bicubic | Even smoother
High quality | More computation
Can create ringing artifacts |
|---------------------|-------------------------------------------|-------------------------------------------|
| Nearest Neighbor | Very fast and simple
Preserves hard edges | Pixelation when upscaling
Jagged edges |
| Bilinear | Smooth result
Better quality than NN | Slight blur on sharp edges
Slower than NN |
| Bicubic | Even smoother
High quality | More computation
Can create ringing artifacts |
#### T 1.2: Image resizing using built-in functions of OpenCV
The
- Scaling using axis-specific factors:
-
-
- Interpolation parameter (
- Determines how pixel values are calculated when resizing.
- Common interpolation methods:
-
-
-
---
Before applying the
- The background is black (pixel value = 0).
- A white square (pixel value = 255) fills the inner 4×4 region, starting from row 1 and column 1.
- A smaller black square (pixel value = 0) is embedded inside the white square, occupying the central 2×2 region.
Once the image (
After generating the test image, the next step is to apply the
To do this, follow these steps:
1. Use
2. Apply different interpolation methods (
3. Display both the original and resized versions of
The
resize() function in OpenCV allows adjusting the size of an image in different ways: - Scaling using axis-specific factors:
-
fx: Scale factor along the horizontal axis. -
fy: Scale factor along the vertical axis. - Interpolation parameter (
interpolation) - Determines how pixel values are calculated when resizing.
- Common interpolation methods:
-
cv2.INTER_NEAREST-
cv2.INTER_LINEAR-
cv2.INTER_CUBIC ---
Before applying the
resize() function, youl will first create a simple grayscale test image using NumPy and Matplotlib. The image will be 6×6 pixels and structured as follows: - The background is black (pixel value = 0).
- A white square (pixel value = 255) fills the inner 4×4 region, starting from row 1 and column 1.
- A smaller black square (pixel value = 0) is embedded inside the white square, occupying the central 2×2 region.
Once the image (
imgtest) is created, it should be displayed before applying any resizing operations. After generating the test image, the next step is to apply the
resize() function to modify its dimensions. This involves adjusting the scale factors along the horizontal (fx) and vertical (fy) axes and experimenting with different interpolation methods. To do this, follow these steps:
1. Use
resize() to scale imgtest by modifying the fx and fy values. 2. Apply different interpolation methods (
INTER_NEAREST, INTER_LINEAR, INTER_CUBIC) and observe their effects. 3. Display both the original and resized versions of
imgtest and analyze the differences. In [10]:
# Create a 6x6 black image
imgtest = np.zeros((6,6), dtype=np.uint8)
# Add white 4x4 square starting from row 1, column 1
imgtest[1:5, 1:5] = 255
# Add a smaller black 2x2 square in the center (row 2-3, col 2-3)
imgtest[2:4, 2:4] = 0
print("Original Test Image (6x6):\n", imgtest)
# Display the image
plt.imshow(imgtest, cmap='gray', vmin=0, vmax=255)
plt.title("Original 6x6 Test Image")
plt.axis('off')
plt.show()Original Test Image (6x6):
[[ 0 0 0 0 0 0]
[ 0 255 255 255 255 0]
[ 0 255 0 0 255 0]
[ 0 255 0 0 255 0]
[ 0 255 255 255 255 0]
[ 0 0 0 0 0 0]]
In [11]:
# New size (scale factors) fx, fy = 10, 10 # upscale 10x to 60x60 # Nearest Neighbor img_nn = cv2.resize(imgtest, dsize=None, fx=fx, fy=fy, interpolation=cv2.INTER_NEAREST) # Bilinear img_linear = cv2.resize(imgtest, dsize=None, fx=fx, fy=fy, interpolation=cv2.INTER_LINEAR) # Bicubic img_cubic = cv2.resize(imgtest, dsize=None, fx=fx, fy=fy, interpolation=cv2.INTER_CUBIC)
In [12]:
plt.figure(figsize=(12,3))
plt.subplot(1,4,1)
plt.imshow(imgtest, cmap='gray', vmin=0, vmax=255)
plt.title('Original 6x6')
plt.axis('off')
plt.subplot(1,4,2)
plt.imshow(img_nn, cmap='gray', vmin=0, vmax=255)
plt.title('Nearest Neighbor')
plt.axis('off')
plt.subplot(1,4,3)
plt.imshow(img_linear, cmap='gray', vmin=0, vmax=255)
plt.title('Bilinear')
plt.axis('off')
plt.subplot(1,4,4)
plt.imshow(img_cubic, cmap='gray', vmin=0, vmax=255)
plt.title('Bicubic')
plt.axis('off')
plt.tight_layout()
plt.show()
| Interpolation Method | Observations |
|---------------------|--------------|
| Nearest Neighbor | Hard edges preserved
Blocky / pixelated appearance |
| Bilinear | Smoother transitions
Slight blur on edges |
| Bicubic | Even smoother than bilinear
Curves appear
Slight ringing on edges |
|---------------------|--------------|
| Nearest Neighbor | Hard edges preserved
Blocky / pixelated appearance |
| Bilinear | Smoother transitions
Slight blur on edges |
| Bicubic | Even smoother than bilinear
Curves appear
Slight ringing on edges |
After experimenting with the test image, you will now apply the
To analyze the effects of resizing, follow these steps:
1. Resize
2. Apply a scaling factor between
3. Resize the image by specifying exact dimensions (
4. Compare the resized outputs with those from
resize() function to a real-world image, cameraman.png. This will allow you to observe how resizing affects a more complex image compared to the simple structured pattern of imgtest. To analyze the effects of resizing, follow these steps:
1. Resize
cameraman.png by adjusting fx and fy values to scale the image both up and down. 2. Apply a scaling factor between
0 and 1 to shrink the image while maintaining aspect ratio. 3. Resize the image by specifying exact dimensions (
rows = 250, cols = 400) instead of using scale factors. 4. Compare the resized outputs with those from
imgtest and discuss how interpolation affects a natural image differently from a synthetic one. In [14]:
# Load the image in grayscale
img_cam = cv2.imread('Images\cameraman.png', cv2.IMREAD_GRAYSCALE)
h, w = img_cam.shape
print(f"Original Cameraman size: {w}x{h}")
plt.imshow(img_cam, cmap='gray')
plt.title(f'Original Cameraman ({w}x{h})')
plt.axis('off')
plt.show()
Original Cameraman size: 256x256
<>:2: SyntaxWarning: invalid escape sequence '\c'
<>:2: SyntaxWarning: invalid escape sequence '\c'
C:\Users\nesri\AppData\Local\Temp\ipykernel_13820\387447558.py:2: SyntaxWarning: invalid escape sequence '\c'
img_cam = cv2.imread('Images\cameraman.png', cv2.IMREAD_GRAYSCALE)
In [15]:
# Upscale 1.5x img_up = cv2.resize(img_cam, dsize=None, fx=1.5, fy=1.5, interpolation=cv2.INTER_LINEAR) # Downscale 0.5x img_down = cv2.resize(img_cam, dsize=None, fx=0.5, fy=0.5, interpolation=cv2.INTER_LINEAR) # Downscale 0.75x (maintaining aspect ratio) img_down75 = cv2.resize(img_cam, dsize=None, fx=0.75, fy=0.75, interpolation=cv2.INTER_LINEAR)
In [16]:
# Resize to 400x250 (cols x rows) img_exact = cv2.resize(img_cam, dsize=(400, 250), interpolation=cv2.INTER_LINEAR)
In [17]:
plt.figure(figsize=(15,5))
plt.subplot(1,5,1)
plt.imshow(img_cam, cmap='gray')
plt.title(f'Original\n{w}x{h}')
plt.axis('off')
plt.subplot(1,5,2)
h_up, w_up = img_up.shape
plt.imshow(img_up, cmap='gray')
plt.title(f'Upscale 1.5x\n{w_up}x{h_up}')
plt.axis('off')
plt.subplot(1,5,3)
h_down, w_down = img_down.shape
plt.imshow(img_down, cmap='gray')
plt.title(f'Downscale 0.5x\n{w_down}x{h_down}')
plt.axis('off')
plt.subplot(1,5,4)
h_down75, w_down75 = img_down75.shape
plt.imshow(img_down75, cmap='gray')
plt.title(f'Downscale 0.75x\n{w_down75}x{h_down75}')
plt.axis('off')
plt.subplot(1,5,5)
h_exact, w_exact = img_exact.shape
plt.imshow(img_exact, cmap='gray')
plt.title(f'Exact 400x250\n{w_exact}x{h_exact}')
plt.axis('off')
plt.tight_layout()
plt.show()
| Resizing Method / Factor | Observations |
|--------------------------|--------------|
| Upscale 1.5x (fx=fy=1.5) | Image gets larger
Some slight blurring with bilinear interpolation
Edges less sharp than nearest neighbor |
| Downscale 0.5x (fx=fy=0.5) | Image shrinks
Details are lost
Interpolation smooths transitions |
| Downscale 0.75x (fx=fy=0.75) | Slightly smaller
Preserves more details than 0.5x
Minor smoothing on edges |
| Resize to exact 400x250 | Non-integer scaling
Interpolation adjusts pixel values
Aspect ratio preserved manually if desired |
|--------------------------|--------------|
| Upscale 1.5x (fx=fy=1.5) | Image gets larger
Some slight blurring with bilinear interpolation
Edges less sharp than nearest neighbor |
| Downscale 0.5x (fx=fy=0.5) | Image shrinks
Details are lost
Interpolation smooths transitions |
| Downscale 0.75x (fx=fy=0.75) | Slightly smaller
Preserves more details than 0.5x
Minor smoothing on edges |
| Resize to exact 400x250 | Non-integer scaling
Interpolation adjusts pixel values
Aspect ratio preserved manually if desired |
Questions:
After applying the
resize() function to both imgtest and cameraman.png, analyze the results by answering the following questions: 1. How does resizing a structured test image (
imgtest) compare to resizing a real-world image (cameraman.png)? 2. What differences do you observe when using different interpolation methods?
3. How does resizing with a scaling factor (
fx, fy) differ from specifying exact dimensions (rows, cols)? 4. Which method produces the best visual quality for upscaling and which one for downscaling? Explain why.
5. Analyse this transformation considering the aspect ratio.
6. Analyze and compare the obtained resized images with those obtained using the function you implementd in T1.1.
---
Add your analysis and comments here
...
...
Task 2: Image translation
Geometric transformations involve mathematical operations that modify the coordinates of the image's pixels. These transformations are typically represented using transformation matrices that define how each point in the image is repositioned.
#### Understanding translation
Translation refers to shifting an image by a specified number of pixels along the x-axis and y-axis. This operation moves every pixel in the image without altering its shape, size or orientation.
Mathematically, translation is represented as follows:
$$
\begin{bmatrix}
x' \\ y'
\end{bmatrix}
=
\begin{bmatrix}
x + \Delta x \\ y + \Delta y
\end{bmatrix}
$$
where:
- \( $x'$ \) and \( $y'$ \) are the new coordinates after translation.
- \( $x$ \) and \( $y$ \) are the original coordinates of the pixel.
- \( $\Delta x$ \) and \( $\Delta y$ \) are the translation offsets along the horizontal and vertical axes, respectively.
Translation is often used for image alignment, object tracking, and perspective adjustments in computer vision tasks.
-------
Exampel of translation
In this task, you will apply image translation using OpenCV's
warpAffine() function to shift an image in different directions. Instructions:
1. Select an image from the given
images folder to perform the translation. 2. Translate the image by shifting:
- 100 pixels horizontally (along the x-axis).
- 200 pixels vertically (along the y-axis).
- Both axes simultaneously (100 pixels right and 200 pixels down).
3. Remove the black pixels that appear after translation.
4. Use the function
warpAffine() from the cv2 module to apply the transformation. 5. Analyze the results by observing how translation affects the image and discussing potential use cases.
In [19]:
# Perform image translation as described above.
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load an example image (you can replace with your choice from 'images' folder)
img = cv2.imread('Images\cameraman.png', cv2.IMREAD_GRAYSCALE)
h, w = img.shape
print(f"Original image size: {w}x{h}")
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.show()Original image size: 256x256
<>:7: SyntaxWarning: invalid escape sequence '\c'
<>:7: SyntaxWarning: invalid escape sequence '\c'
C:\Users\nesri\AppData\Local\Temp\ipykernel_13820\679582032.py:7: SyntaxWarning: invalid escape sequence '\c'
img = cv2.imread('Images\cameraman.png', cv2.IMREAD_GRAYSCALE)
In [20]:
def translate_image(image, tx=0, ty=0):
"""
Translate an image by tx (x-axis) and ty (y-axis) using warpAffine.
Fills empty areas by replicating edge pixels to remove black borders.
"""
rows, cols = image.shape
# Translation matrix
M = np.float32([[1, 0, tx],
[0, 1, ty]])
# Apply warpAffine
translated = cv2.warpAffine(image, M, (cols, rows), borderMode=cv2.BORDER_REPLICATE)
return translatedIn [21]:
# 100 pixels horizontally img_tx = translate_image(img, tx=100, ty=0) # 200 pixels vertically img_ty = translate_image(img, tx=0, ty=200) # Both axes: 100 right, 200 down img_txy = translate_image(img, tx=100, ty=200)
In [22]:
plt.figure(figsize=(15,4))
plt.subplot(1,4,1)
plt.imshow(img, cmap='gray')
plt.title('Original')
plt.axis('off')
plt.subplot(1,4,2)
plt.imshow(img_tx, cmap='gray')
plt.title('Shift 100 px right')
plt.axis('off')
plt.subplot(1,4,3)
plt.imshow(img_ty, cmap='gray')
plt.title('Shift 200 px down')
plt.axis('off')
plt.subplot(1,4,4)
plt.imshow(img_txy, cmap='gray')
plt.title('Shift 100 right & 200 down')
plt.axis('off')
plt.tight_layout()
plt.show()
| Translation Direction | Observations |
|---------------------------|--------------|
| 100 px horizontal (right) | Image moves right
Left side pixels replicated
No black borders due to replication |
| 200 px vertical (down) | Image moves down
Top pixels replicated
Smooth edge without black areas |
| 100 px right & 200 px down | Combination of horizontal and vertical shift
Image content preserved
Edges replicated to fill space |
|---------------------------|--------------|
| 100 px horizontal (right) | Image moves right
Left side pixels replicated
No black borders due to replication |
| 200 px vertical (down) | Image moves down
Top pixels replicated
Smooth edge without black areas |
| 100 px right & 200 px down | Combination of horizontal and vertical shift
Image content preserved
Edges replicated to fill space |
Questions:
1. How does translating the image affect its appearance?
2. What happens to the pixels that are shifted beyond the image boundaries?
3. Why do black pixels appear after translation, and how can they be removed effectively?
4. Compare translating along a single axis ($x$ or $y$) vs. translating along both axes simultaneously—what differences do you notice?
Add your analysis and comments here
...
#### Challenge 1: Translating an Object
In this challenge, you will apply translation to animate the movement of an object inside an image.
Use
In this challenge, you will apply translation to animate the movement of an object inside an image.
Use
Circle.png as the input image.
In [23]:
# Challenge 1: Apply static translation to the image.
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load the Circle image
img = cv2.imread('Images\Circle.png', cv2.IMREAD_UNCHANGED) # supports alpha channel if PNG
h, w = img.shape[:2]
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB)) if img.shape[2]==3 else plt.imshow(img)
plt.title('Original Circle Image')
plt.axis('off')
plt.show()<>:7: SyntaxWarning: invalid escape sequence '\C'
<>:7: SyntaxWarning: invalid escape sequence '\C'
C:\Users\nesri\AppData\Local\Temp\ipykernel_13820\863208935.py:7: SyntaxWarning: invalid escape sequence '\C'
img = cv2.imread('Images\Circle.png', cv2.IMREAD_UNCHANGED) # supports alpha channel if PNG
In [24]:
def translate_image(image, tx=0, ty=0):
"""
Translate image by tx (x-axis) and ty (y-axis) using warpAffine.
Uses border replication to avoid black pixels.
"""
rows, cols = image.shape[:2]
M = np.float32([[1, 0, tx],
[0, 1, ty]])
translated = cv2.warpAffine(image, M, (cols, rows), borderMode=cv2.BORDER_REPLICATE)
return translatedIn [25]:
# Number of frames
num_frames = 20
shift_per_frame = 10 # pixels per frame
plt.figure(figsize=(10,5))
for i in range(num_frames):
tx = i * shift_per_frame # move right each frame
ty = 0 # no vertical movement
img_moved = translate_image(img, tx=tx, ty=ty)
plt.clf()
plt.imshow(cv2.cvtColor(img_moved, cv2.COLOR_BGR2RGB)) if img.shape[2]==3 else plt.imshow(img_moved)
plt.title(f'Frame {i+1}: Shift {tx}px right')
plt.axis('off')
plt.pause(0.2) # pause 200ms per frame
plt.show()
| Animation Step | Observations |
|----------------|--------------|
| Initial frame | Circle at original position |
| Intermediate frames | Circle moves gradually to the right
Image edges replicated to avoid black borders |
| Final frame | Circle reaches maximum shift
Movement appears smooth and continuous |
|----------------|--------------|
| Initial frame | Circle at original position |
| Intermediate frames | Circle moves gradually to the right
Image edges replicated to avoid black borders |
| Final frame | Circle reaches maximum shift
Movement appears smooth and continuous |
#### Challenge 2: Dynamic Object Translation
1. Perform horizontal translation → Shift the white circle continuously to the right. Once it reaches the image boundary, it should reappear from the left side.
2. Perform vertical translation → Shift the circle downward, ensuring it wraps around and reappears from the top.
3. Apply sinewave-based horizontal translation → Make the circle follow a sinusoidal path as it moves horizontally.
4. Generate an animation to visualize the movement over time.
To create a video file, you first need to initialize a
- Step 1: Define the codec (video format)
- Step 2: Create the video writer
- Step 3: Write frames (each frame corresponds to one translation step) to the video inside a loop
- Step 4: Release the video writer (finalize the video file once the loop ends)
1. Perform horizontal translation → Shift the white circle continuously to the right. Once it reaches the image boundary, it should reappear from the left side.
2. Perform vertical translation → Shift the circle downward, ensuring it wraps around and reappears from the top.
3. Apply sinewave-based horizontal translation → Make the circle follow a sinusoidal path as it moves horizontally.
4. Generate an animation to visualize the movement over time.
To create a video file, you first need to initialize a
VideoWriter object. - Step 1: Define the codec (video format)
fourcc = cv2.VideoWriter_fourcc(*'mp4v')- Step 2: Create the video writer
video_writer = cv2.VideoWriter('your/saving/path/output_video.mp4', fourcc, 30, (image_width, image_height))- Step 3: Write frames (each frame corresponds to one translation step) to the video inside a loop
video_writer.write(frame)- Step 4: Release the video writer (finalize the video file once the loop ends)
video_writer.release()In [27]:
# Challenge 2: Animate translation using OpenCV VideoWriter.
import cv2
import numpy as np
# Load Circle.png
img = cv2.imread('Images\Circle.png', cv2.IMREAD_UNCHANGED) # preserves alpha if PNG
h, w = img.shape[:2]<>:6: SyntaxWarning: invalid escape sequence '\C'
<>:6: SyntaxWarning: invalid escape sequence '\C'
C:\Users\nesri\AppData\Local\Temp\ipykernel_13820\3962405672.py:6: SyntaxWarning: invalid escape sequence '\C'
img = cv2.imread('Images\Circle.png', cv2.IMREAD_UNCHANGED) # preserves alpha if PNG
In [28]:
# Video parameters
output_path = 'dynamic_translation.mp4'
fps = 30
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
video_writer = cv2.VideoWriter(output_path, fourcc, fps, (w, h))
# Function to convert image with alpha to BGR for video (if PNG has alpha)
def to_bgr(img):
if img.shape[2] == 4: # has alpha
alpha = img[:,:,3]/255.0
bgr = img[:,:,:3].astype(np.float32)
bgr[:,:,0] = bgr[:,:,0]*alpha + (1-alpha)*0 # background=black
bgr[:,:,1] = bgr[:,:,1]*alpha + (1-alpha)*0
bgr[:,:,2] = bgr[:,:,2]*alpha + (1-alpha)*0
return bgr.astype(np.uint8)
return imgIn [29]:
def translate_wrap(image, tx=0, ty=0):
"""
Translate an image with wrap-around effect.
Positive tx moves right, positive ty moves down.
"""
rows, cols = image.shape[:2]
# Horizontal wrap
tx = tx % cols
ty = ty % rows
# Horizontal shift
Mx = np.float32([[1,0,tx],[0,1,0]])
shifted_x = cv2.warpAffine(image, Mx, (cols, rows), borderMode=cv2.BORDER_WRAP)
# Vertical shift
My = np.float32([[1,0,0],[0,1,ty]])
shifted_xy = cv2.warpAffine(shifted_x, My, (cols, rows), borderMode=cv2.BORDER_WRAP)
return shifted_xyIn [30]:
num_frames = 120 # 4 seconds at 30fps
# Parameters for sinewave motion
amplitude = 50 # vertical displacement
frequency = 2 * np.pi / num_frames # one full wave over animation
for i in range(num_frames):
# Horizontal translation with wrap
tx_h = i * 5 # 5 px per frame
frame_h = translate_wrap(img, tx=tx_h, ty=0)
# Vertical translation with wrap
ty_v = i * 3
frame_v = translate_wrap(img, tx=0, ty=ty_v)
# Sinewave horizontal translation
tx_sine = i * 5
ty_sine = int(amplitude * np.sin(frequency * i))
frame_sine = translate_wrap(img, tx=tx_sine, ty=ty_sine)
# Combine or choose one to write (example: sinewave)
video_writer.write(to_bgr(frame_sine))In [31]:
video_writer.release()
print("Video saved as dynamic_translation.mp4")Video saved as dynamic_translation.mp4
Task 3: Image Rotation
Rotation is a geometric transformation that rotates an image around a fixed point (usually the center). The transformation is represented by the following mathematical formula:
$$
\begin{bmatrix}
x' \\ y'
\end{bmatrix} =
\begin{bmatrix}
\cos\theta & -\sin\theta \\
\sin\theta & \cos\theta
\end{bmatrix}
\begin{bmatrix}
x \\ y
\end{bmatrix}
$$
where:
- \( $x'$ \), \( $y'$ \) are the new coordinates after rotation.
- \( $x$ \), \( $y$ \) are the original coordinates of the pixel.
- \( $\theta$ \) is the rotation angle in degrees.
---
Instructions:
1. Choose an image from the
images folder.1. Write a program to rotate an image at different angles, such as 45°, 90°, and a full 360° rotation.
2. Use
cv2.getRotationMatrix2D() to generate the rotation matrix and apply it to the image. 3. Analyze the results by observing how rotation affects the image, especially at different angles.
In [33]:
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load image (replace with any image from 'images' folder)
img = cv2.imread('Images\cameraman.png', cv2.IMREAD_GRAYSCALE)
h, w = img.shape
print(f"Original image size: {w}x{h}")
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.show()Original image size: 256x256
<>:6: SyntaxWarning: invalid escape sequence '\c'
<>:6: SyntaxWarning: invalid escape sequence '\c'
C:\Users\nesri\AppData\Local\Temp\ipykernel_13820\1102725967.py:6: SyntaxWarning: invalid escape sequence '\c'
img = cv2.imread('Images\cameraman.png', cv2.IMREAD_GRAYSCALE)
In [34]:
def rotate_image(image, angle):
"""
Rotate an image around its center by the given angle (in degrees)
"""
h, w = image.shape[:2]
center = (w//2, h//2)
# Rotation matrix
M = cv2.getRotationMatrix2D(center, angle, 1) # scale=1
rotated = cv2.warpAffine(image, M, (w, h), borderMode=cv2.BORDER_REPLICATE)
return rotatedIn [35]:
angles = [45, 90, 180, 270, 360] # degrees rotated_images = [rotate_image(img, angle) for angle in angles]
In [36]:
plt.figure(figsize=(15,5))
plt.subplot(1, len(angles)+1, 1)
plt.imshow(img, cmap='gray')
plt.title('Original')
plt.axis('off')
for i, rotated in enumerate(rotated_images):
plt.subplot(1, len(angles)+1, i+2)
plt.imshow(rotated, cmap='gray')
plt.title(f'{angles[i]}°')
plt.axis('off')
plt.tight_layout()
plt.show()
| Rotation Angle | Observations |
|----------------|--------------|
| 45° | Image rotated diagonally
Edges become less sharp
Some interpolation artifacts appear |
| 90° | Image rotated clockwise
Orientation changes
Edges mostly preserved due to 90° alignment |
| 180° | Image upside down
Content preserved
Edges slightly smoothed by interpolation |
| 270° | Image rotated counterclockwise
Orientation changed
Similar behavior to 90° rotation |
| 360° | Full rotation, returns to original
No visible change, slight interpolation may blur edges slightly |
|----------------|--------------|
| 45° | Image rotated diagonally
Edges become less sharp
Some interpolation artifacts appear |
| 90° | Image rotated clockwise
Orientation changes
Edges mostly preserved due to 90° alignment |
| 180° | Image upside down
Content preserved
Edges slightly smoothed by interpolation |
| 270° | Image rotated counterclockwise
Orientation changed
Similar behavior to 90° rotation |
| 360° | Full rotation, returns to original
No visible change, slight interpolation may blur edges slightly |
Questions:
1. What happens to the image dimensions after rotation? Why do some rotations introduce black borders?
2. How does OpenCV handle out-of-frame pixels during rotation?
Add your analysis and comments here
...
#### Challenge: Custom Rotation Point
By default, image rotation occurs around the center of the image. In this challenge, you will modify the transformation to rotate an image around a custom point instead.
1. Use the same image as before or choose a different one from the
2. Select a custom pivot point (e.g., a corner, an off-center point, or a specific feature in the image).
3. Use
4. Apply the rotation and display the resulting image.
5. Analyze the difference between center-based rotation and custom-point rotation.
By default, image rotation occurs around the center of the image. In this challenge, you will modify the transformation to rotate an image around a custom point instead.
Instructions:
1. Use the same image as before or choose a different one from the
images folder. 2. Select a custom pivot point (e.g., a corner, an off-center point, or a specific feature in the image).
3. Use
cv2.getRotationMatrix2D() to compute the transformation matrix based on the chosen pivot point. 4. Apply the rotation and display the resulting image.
5. Analyze the difference between center-based rotation and custom-point rotation.
In [39]:
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load image
img = cv2.imread('Images/cameraman.png', cv2.IMREAD_GRAYSCALE)
h, w = img.shape
print(f"Original image size: {w}x{h}")
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.show()Original image size: 256x256
In [37]:
def rotate_image_custom_pivot(image, angle, pivot):
"""
Rotate an image around a custom pivot point.
Parameters:
image: input grayscale image
angle: rotation angle in degrees (clockwise)
pivot: tuple (x, y) for rotation pivot point
"""
# Rotation matrix
M = cv2.getRotationMatrix2D(pivot, angle, 1) # scale=1
h, w = image.shape[:2]
rotated = cv2.warpAffine(image, M, (w, h), borderMode=cv2.BORDER_REPLICATE)
return rotatedIn [38]:
angles = [45, 90] # rotation angles
pivot_points = [(0,0), (w//4, h//4)] # top-left corner, off-center
plt.figure(figsize=(12,5))
for i, pivot in enumerate(pivot_points):
for j, angle in enumerate(angles):
rotated = rotate_image_custom_pivot(img, angle, pivot)
plt.subplot(len(pivot_points), len(angles), i*len(angles)+j+1)
plt.imshow(rotated, cmap='gray')
plt.title(f'Angle: {angle}°\nPivot: {pivot}')
plt.axis('off')
plt.tight_layout()
plt.show()
| Pivot Point | Rotation Angle | Observations |
|------------------|----------------|--------------|
| Top-left corner (0,0) | 45° | Image rotates around the top-left
Bottom and right edges swing outward
Much of the image moves diagonally |
| Top-left corner (0,0) | 90° | Rotates clockwise around corner
Original top-left remains fixed
Other parts move to new positions |
| Off-center (w/4,h/4) | 45° | Rotation occurs around internal point
Center of image shifts visually
Content appears to orbit around the pivot |
| Off-center (w/4,h/4) | 90° | Image rotates around custom point
Original pivot stays fixed
Edge movement is asymmetric compared to center rotation |
|------------------|----------------|--------------|
| Top-left corner (0,0) | 45° | Image rotates around the top-left
Bottom and right edges swing outward
Much of the image moves diagonally |
| Top-left corner (0,0) | 90° | Rotates clockwise around corner
Original top-left remains fixed
Other parts move to new positions |
| Off-center (w/4,h/4) | 45° | Rotation occurs around internal point
Center of image shifts visually
Content appears to orbit around the pivot |
| Off-center (w/4,h/4) | 90° | Image rotates around custom point
Original pivot stays fixed
Edge movement is asymmetric compared to center rotation |
Task 4: Affine Transformation
Affine transformations are a class of geometric transformations that preserve collinearity (straight lines remain straight) and ratios of distances between points. They include operations such as scaling, rotation, shearing, and translation.
Analysis of the Transformation:
1. Analyze the given output and determine what type of transformation has been applied to the
pepper.png image. 2. Explain the effects of the transformation and how it affects the image structure.
Add your analysis and comments here
...
Instructions:
1. Use the appropriate OpenCV functions to reproduce the transformations observed in the output.
2. Display the transformed images and compare them with the original.
In [40]:
# Apply and reproduce the affine transformations observed in the given output.
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load image
img = cv2.imread('Images/cameraman.png', cv2.IMREAD_GRAYSCALE)
h, w = img.shape
print(f"Original image size: {w}x{h}")
plt.imshow(img, cmap='gray')
plt.title('Original Image')
plt.axis('off')
plt.show()Original image size: 256x256
In [41]:
# Translation
def translate(image, tx=0, ty=0):
M = np.float32([[1,0,tx],[0,1,ty]])
return cv2.warpAffine(image, M, (image.shape[1], image.shape[0]), borderMode=cv2.BORDER_REPLICATE)
# Rotation around center
def rotate(image, angle):
center = (image.shape[1]//2, image.shape[0]//2)
M = cv2.getRotationMatrix2D(center, angle, 1)
return cv2.warpAffine(image, M, (image.shape[1], image.shape[0]), borderMode=cv2.BORDER_REPLICATE)
# Scaling
def scale(image, fx=1, fy=1):
return cv2.resize(image, None, fx=fx, fy=fy, interpolation=cv2.INTER_LINEAR)
# Horizontal flip
def flip_horizontal(image):
return cv2.flip(image, 1)
# Vertical flip
def flip_vertical(image):
return cv2.flip(image, 0)In [42]:
# Example transformations
transformed_images = {
'Translate (100 right, 50 down)': translate(img, tx=100, ty=50),
'Rotate 45°': rotate(img, 45),
'Scale 1.5x': scale(img, fx=1.5, fy=1.5),
'Flip Horizontal': flip_horizontal(img),
'Flip Vertical': flip_vertical(img)
}In [43]:
plt.figure(figsize=(18,5))
# Original
plt.subplot(1, len(transformed_images)+1, 1)
plt.imshow(img, cmap='gray')
plt.title('Original')
plt.axis('off')
# Transformed
for i, (name, t_img) in enumerate(transformed_images.items()):
plt.subplot(1, len(transformed_images)+1, i+2)
plt.imshow(t_img, cmap='gray')
plt.title(name)
plt.axis('off')
plt.tight_layout()
plt.show()
| Transformation | Observations |
|----------------------------|--------------|
| Translate (100 right, 50 down) | Image content moves diagonally
Empty regions filled via border replication |
| Rotate 45° | Image rotates clockwise around center
Edges interpolated slightly |
| Scale 1.5x | Image enlarges
Some blurring occurs due to interpolation |
| Flip Horizontal | Image mirrored along vertical axis
Left/right reversed |
| Flip Vertical | Image mirrored along horizontal axis
Top/bottom reversed |
|----------------------------|--------------|
| Translate (100 right, 50 down) | Image content moves diagonally
Empty regions filled via border replication |
| Rotate 45° | Image rotates clockwise around center
Edges interpolated slightly |
| Scale 1.5x | Image enlarges
Some blurring occurs due to interpolation |
| Flip Horizontal | Image mirrored along vertical axis
Left/right reversed |
| Flip Vertical | Image mirrored along horizontal axis
Top/bottom reversed |
#### Challenge: Aligning a Tilted Image
In this challenge, you will correct the alignment of an image that appears tilted or skewed.
- Use
- Apply the necessary transformations to straighten the image.
1. Load
2. Determine the transformation needed to correct its alignment (e.g., rotation, affine transformation, perspective correction).
3. Use OpenCV functions such as
4. Display both the original and corrected images side by side for comparison.
5. Analyze the results, explaining how alignment correction improves image perception.
In this challenge, you will correct the alignment of an image that appears tilted or skewed.
- Use
leaning.jpg from the images folder as the input image. - Apply the necessary transformations to straighten the image.
Instructions:
1. Load
leaning.jpg and analyze its tilt. 2. Determine the transformation needed to correct its alignment (e.g., rotation, affine transformation, perspective correction).
3. Use OpenCV functions such as
cv2.getRotationMatrix2D() or cv2.warpAffine() to straighten the image. 4. Display both the original and corrected images side by side for comparison.
5. Analyze the results, explaining how alignment correction improves image perception.
In [45]:
# Apply transformation to align leaning.jpg.
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load tilted image
img = cv2.imread('Images/leaning.jpg')
h, w = img.shape[:2]
print(f"Original image size: {w}x{h}")
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Original Tilted Image')
plt.axis('off')
plt.show()Original image size: 540x312
In [46]:
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray, 50, 150)
plt.imshow(edges, cmap='gray')
plt.title('Edges for Tilt Analysis')
plt.axis('off')
plt.show()
In [47]:
lines = cv2.HoughLines(edges, 1, np.pi/180, threshold=100)
angles = []
if lines is not None:
for rho,theta in lines[:,0]:
angle = (theta*180/np.pi) - 90 # convert to degrees, horizontal reference
angles.append(angle)
# Average angle of detected lines
if angles:
tilt_angle = np.mean(angles)
else:
tilt_angle = 0
print(f"Estimated tilt angle: {tilt_angle:.2f}°")Estimated tilt angle: 2.54°
In [48]:
def rotate_image(image, angle):
h, w = image.shape[:2]
center = (w//2, h//2)
M = cv2.getRotationMatrix2D(center, angle, 1)
rotated = cv2.warpAffine(image, M, (w, h), borderMode=cv2.BORDER_REPLICATE)
return rotated
corrected = rotate_image(img, -tilt_angle)In [49]:
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Original Tilted Image')
plt.axis('off')
plt.subplot(1,2,2)
plt.imshow(cv2.cvtColor(corrected, cv2.COLOR_BGR2RGB))
plt.title('Corrected Alignment')
plt.axis('off')
plt.tight_layout()
plt.show()
| Transformation | Observations |
|--------------------------|--------------|
| Original Tilted Image | Image appears slanted
Objects are skewed
Harder to analyze visually |
| Corrected Alignment | Tilt removed by rotation
Horizontal and vertical lines now aligned
Image perception improves significantly
Content easier to interpret |
|--------------------------|--------------|
| Original Tilted Image | Image appears slanted
Objects are skewed
Harder to analyze visually |
| Corrected Alignment | Tilt removed by rotation
Horizontal and vertical lines now aligned
Image perception improves significantly
Content easier to interpret |
Add your analysis and comments here
...
...
Task 5: Perspective Transformation
Perspective transformation is a geometric operation that maps an image from one perspective to another, commonly used for rectifying distortions or simulating different viewpoints.
Instructions:
1. Analyze the given transformed images and identify the type of perspective transformations applied.
2. Explain how these transformations affect the image structure, such as warping, foreshortening, or rectification.
3. Use OpenCV functions like
cv2.getPerspectiveTransform() and cv2.warpPerspective() to reproduce the transformations using the Earth.bmp image. 4. Compare the transformed images with the original and discuss your observations.
In [51]:
# Apply perspective transformation here.
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load Earth.bmp
img = cv2.imread('Images/Earth.bmp')
h, w = img.shape[:2]
print(f"Original image size: {w}x{h}")
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.show()Original image size: 300x307
In [52]:
# Source points (corners of the original image)
src_pts = np.float32([[0,0], [w-1,0], [w-1,h-1], [0,h-1]])
# Destination points (simulate perspective tilt)
dst_pts = np.float32([
[50,50], # top-left moves inward
[w-50, 0], # top-right moves inward
[w-10, h-10], # bottom-right slightly shifted
[10, h-20] # bottom-left slightly shifted
])In [53]:
# Source points (corners of the original image)
src_pts = np.float32([[0,0], [w-1,0], [w-1,h-1], [0,h-1]])
# Destination points (simulate perspective tilt)
dst_pts = np.float32([
[50,50], # top-left moves inward
[w-50, 0], # top-right moves inward
[w-10, h-10], # bottom-right slightly shifted
[10, h-20] # bottom-left slightly shifted
])In [54]:
M = cv2.getPerspectiveTransform(src_pts, dst_pts)
In [55]:
warped = cv2.warpPerspective(img, M, (w, h))
In [56]:
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Original Image')
plt.axis('off')
plt.subplot(1,2,2)
plt.imshow(cv2.cvtColor(warped, cv2.COLOR_BGR2RGB))
plt.title('Perspective Transformed')
plt.axis('off')
plt.tight_layout()
plt.show()
| Transformation | Observations |
|----------------------------|--------------|
| Perspective Transformation | The image appears tilted or foreshortened
Top edges appear narrower, bottom edges wider
Simulates a viewpoint change
Useful for rectifying distortions or creating 3D-like effects |
|----------------------------|--------------|
| Perspective Transformation | The image appears tilted or foreshortened
Top edges appear narrower, bottom edges wider
Simulates a viewpoint change
Useful for rectifying distortions or creating 3D-like effects |
Add your analysis and comments here
...
...
#### Challenge: Bird's Eye View Transformation
In this challenge, you will apply geometric transformations to align an image similar to the example shown below.
- Use
- Apply the same transformation as demonstrated in the reference image below.
1. Apply a perspective transformation to align
2. Apply the transformation and display the corrected image.
3. Compare your result with the original image and the reference example.
In this challenge, you will apply geometric transformations to align an image similar to the example shown below.
- Use
road.png from the images folder as the input image. - Apply the same transformation as demonstrated in the reference image below.
Instructions:
1. Apply a perspective transformation to align
road.png using cv2.getPerspectiveTransform() and cv2.warpPerspective(). 2. Apply the transformation and display the corrected image.
3. Compare your result with the original image and the reference example.
In [57]:
import cv2
import numpy as np
import matplotlib.pyplot as plt
# Load road.png
img = cv2.imread('Images/road.png')
h, w = img.shape[:2]
print(f"Original image size: {w}x{h}")
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Original Road Image')
plt.axis('off')
plt.show()Original image size: 628x375
In [58]:
# Example source points (adjust based on your road.png)
src_pts = np.float32([
[570, 470], # top-left of lane
[710, 470], # top-right of lane
[1100, 720], # bottom-right
[200, 720] # bottom-left
])
# Destination points for a top-down rectangle
dst_pts = np.float32([
[200, 0], # top-left
[900, 0], # top-right
[900, 720], # bottom-right
[200, 720] # bottom-left
])In [59]:
M = cv2.getPerspectiveTransform(src_pts, dst_pts)
In [60]:
warped = cv2.warpPerspective(img, M, (w, h))
In [61]:
plt.figure(figsize=(12,6))
plt.subplot(1,2,1)
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
plt.title('Original Road Image')
plt.axis('off')
plt.subplot(1,2,2)
plt.imshow(cv2.cvtColor(warped, cv2.COLOR_BGR2RGB))
plt.title('Bird\'s Eye View')
plt.axis('off')
plt.tight_layout()
plt.show()
| Transformation | Observations |
|------------------------|--------------|
| Perspective Warp | Lane is now aligned vertically
Simulates top-down (bird’s-eye) view
Useful for lane detection, autonomous driving, and path planning
Objects retain relative proportions along road |
|------------------------|--------------|
| Perspective Warp | Lane is now aligned vertically
Simulates top-down (bird’s-eye) view
Useful for lane detection, autonomous driving, and path planning
Objects retain relative proportions along road |
---
Bitwise logical operators allow us to perform pixel-wise operations on images. These operations are useful for masking, blending, and extracting regions of interest in an image.
In OpenCV, bitwise operations are applied using
These operations are commonly used in image processing tasks, such as:
- Creating masks to isolate parts of an image
- Combining or blending two images based on logical conditions
- Extracting foreground or background elements
----
Manipulation 2: Bitwise Logical Operators
Bitwise logical operators allow us to perform pixel-wise operations on images. These operations are useful for masking, blending, and extracting regions of interest in an image.
In OpenCV, bitwise operations are applied using
cv2.bitwise_*() functions, which perform logical operations at the pixel level. Each pixel's value is modified based on the corresponding pixel values from input images, following standard bitwise logic rules (AND, OR, XOR, NOT). These operations are commonly used in image processing tasks, such as:
- Creating masks to isolate parts of an image
- Combining or blending two images based on logical conditions
- Extracting foreground or background elements
----
Task 1: Creating and Applying Logical Operations on Binary Images
In this task, you will generate two binary images and apply logical operations both manually and using OpenCV functions.
Image Specifications:
- Image A (256×256 pixels) contains a black rectangle at coordinates $90 ≤ x ≤ 120$ and $90 ≤ y ≤ 180$.
- Image B (256×256 pixels) contains a black square at coordinates $110 ≤ x ≤ 150$ and $110 ≤ y ≤ 150$.
Instructions:
1. Create Image A and Image B using NumPy, ensuring correct pixel placements.
2. Implement logical operations (NOT, AND, OR, XOR) manually, without using OpenCV functions.
3. Apply logical operations using OpenCV functions:
-
cv2.bitwise_not() -
cv2.bitwise_and() -
cv2.bitwise_or() -
cv2.bitwise_xor() 4. Analyze the results, comparing the output of manual implementation with OpenCV’s built-in functions.
In [62]:
# Add the corresponding code here. import cv2 import numpy as np import matplotlib.pyplot as plt
In [63]:
# Image dimensions
h, w = 256, 256
# Create white images (255 = white, 0 = black)
A = np.ones((h,w), dtype=np.uint8) * 255
B = np.ones((h,w), dtype=np.uint8) * 255
# Draw black rectangle in Image A: 90 ≤ x ≤ 120, 90 ≤ y ≤ 180
A[90:181, 90:121] = 0
# Draw black square in Image B: 110 ≤ x ≤ 150, 110 ≤ y ≤ 150
B[110:151, 110:151] = 0
# Display A and B
plt.figure(figsize=(10,5))
plt.subplot(1,2,1)
plt.imshow(A, cmap='gray')
plt.title('Image A')
plt.axis('off')
plt.subplot(1,2,2)
plt.imshow(B, cmap='gray')
plt.title('Image B')
plt.axis('off')
plt.show()
In [64]:
# NOT NOT_A = 255 - A NOT_B = 255 - B # AND AND_AB = np.minimum(A, B) # OR OR_AB = np.maximum(A, B) # XOR XOR_AB = np.where(A==B, 0, 255)
In [65]:
NOT_A_cv = cv2.bitwise_not(A) NOT_B_cv = cv2.bitwise_not(B) AND_AB_cv = cv2.bitwise_and(A, B) OR_AB_cv = cv2.bitwise_or(A, B) XOR_AB_cv = cv2.bitwise_xor(A, B)
In [66]:
operations = {
"NOT A": (NOT_A, NOT_A_cv),
"NOT B": (NOT_B, NOT_B_cv),
"A AND B": (AND_AB, AND_AB_cv),
"A OR B": (OR_AB, OR_AB_cv),
"A XOR B": (XOR_AB, XOR_AB_cv)
}
plt.figure(figsize=(15,10))
i = 1
for name, (manual, opencv) in operations.items():
plt.subplot(len(operations),2,i)
plt.imshow(manual, cmap='gray')
plt.title(f"Manual {name}")
plt.axis('off')
plt.subplot(len(operations),2,i+1)
plt.imshow(opencv, cmap='gray')
plt.title(f"OpenCV {name}")
plt.axis('off')
i += 2
plt.tight_layout()
plt.show()
Add your analysis and comments here
...
...
| Operation | Observations |
|------------|--------------|
| NOT A | All black pixels in A become white, and white become black. Manual and OpenCV results match perfectly. |
| NOT B | All black pixels in B become white, and white become black. Manual and OpenCV results match perfectly. |
| A AND B | Only pixels that are black in both A and B remain black. Overlapping region (110≤x≤120, 110≤y≤150) is black, rest is white. Manual and OpenCV results match. |
| A OR B | Pixels that are black in A or B are black. Larger black region combining rectangle and square. Manual and OpenCV results match. |
| A XOR B | Pixels black in only one of the images are black. Overlapping region is white. Manual and OpenCV results match. |
|------------|--------------|
| NOT A | All black pixels in A become white, and white become black. Manual and OpenCV results match perfectly. |
| NOT B | All black pixels in B become white, and white become black. Manual and OpenCV results match perfectly. |
| A AND B | Only pixels that are black in both A and B remain black. Overlapping region (110≤x≤120, 110≤y≤150) is black, rest is white. Manual and OpenCV results match. |
| A OR B | Pixels that are black in A or B are black. Larger black region combining rectangle and square. Manual and OpenCV results match. |
| A XOR B | Pixels black in only one of the images are black. Overlapping region is white. Manual and OpenCV results match. |
Task 2: Applying Bitwise Logical Operators on Images
In this task, you will apply bitwise logical operations to different image pairs using OpenCV functions that you have previously used.
Instructions:
1. Apply the bitwise AND operation on
Brain.png and BrainM.png using cv2.bitwise_and(). 2. Apply the bitwise OR operation on
Brain.png and BrainM.png using cv2.bitwise_or(). 3. Apply the bitwise XOR operation on
Before.png and After.png using cv2.bitwise_xor(). 4. Apply the bitwise NOT operation separately on
QR.png and Jellybeans.png using cv2.bitwise_not(). 5. Display the results and analyze how each operation affects the images.
In [67]:
# Apply bitwise logical operations on the given image pairs using OpenCV. import cv2 import numpy as np import matplotlib.pyplot as plt
In [68]:
# Load images in grayscale
brain = cv2.imread('Images/Brain.png', cv2.IMREAD_GRAYSCALE)
brain_mask = cv2.imread('Images/BrainM.png', cv2.IMREAD_GRAYSCALE)
before = cv2.imread('Images/Before.png', cv2.IMREAD_GRAYSCALE)
after = cv2.imread('Images/After.png', cv2.IMREAD_GRAYSCALE)
qr = cv2.imread('Images/QR.png', cv2.IMREAD_GRAYSCALE)
jelly = cv2.imread('Images/Jellybeans.png', cv2.IMREAD_GRAYSCALE)
# Check if images are loaded
images = [brain, brain_mask, before, after, qr, jelly]
if any(img is None for img in images):
print("Error: One or more images not found. Check file paths!")In [69]:
# Brain images brain_and = cv2.bitwise_and(brain, brain_mask) brain_or = cv2.bitwise_or(brain, brain_mask) # Before and After images before_xor_after = cv2.bitwise_xor(before, after) # NOT operations qr_not = cv2.bitwise_not(qr) jelly_not = cv2.bitwise_not(jelly)
In [70]:
plt.figure(figsize=(15,10))
# Brain AND
plt.subplot(2,3,1)
plt.imshow(brain_and, cmap='gray')
plt.title('Brain AND BrainM')
plt.axis('off')
# Brain OR
plt.subplot(2,3,2)
plt.imshow(brain_or, cmap='gray')
plt.title('Brain OR BrainM')
plt.axis('off')
# Before XOR After
plt.subplot(2,3,3)
plt.imshow(before_xor_after, cmap='gray')
plt.title('Before XOR After')
plt.axis('off')
# QR NOT
plt.subplot(2,3,4)
plt.imshow(qr_not, cmap='gray')
plt.title('NOT QR')
plt.axis('off')
# Jellybeans NOT
plt.subplot(2,3,5)
plt.imshow(jelly_not, cmap='gray')
plt.title('NOT Jellybeans')
plt.axis('off')
plt.tight_layout()
plt.show()
| Operation | Observations |
|------------------------|--------------|
| Brain AND BrainM | Keeps only pixels that are non-zero in both images.
Useful for masking the brain region precisely. |
| Brain OR BrainM | Combines both images, showing all non-zero pixels from either image.
Highlights full brain plus mask areas. |
| Before XOR After | Highlights differences between the two images.
Used for detecting changes or motion. |
| NOT QR | Inverts the QR image.
Black becomes white and white becomes black, helpful in preprocessing for detection. |
| NOT Jellybeans | Inverts the image.
Useful for segmentation or highlighting foreground objects. |
|------------------------|--------------|
| Brain AND BrainM | Keeps only pixels that are non-zero in both images.
Useful for masking the brain region precisely. |
| Brain OR BrainM | Combines both images, showing all non-zero pixels from either image.
Highlights full brain plus mask areas. |
| Before XOR After | Highlights differences between the two images.
Used for detecting changes or motion. |
| NOT QR | Inverts the QR image.
Black becomes white and white becomes black, helpful in preprocessing for detection. |
| NOT Jellybeans | Inverts the image.
Useful for segmentation or highlighting foreground objects. |